
// auto generate 157 apis
#include "cublas_subset.h"
#include "macro.h"
#include "hook.h"
#include "trace.h"

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasInit() {
    HOOK_TRACE_PERF("cublasInit");
    using func_ptr = cublasStatus (*)();
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasInit"));
    HOOK_CHECK(func_entry);

    //! 加入我Hook的逻辑
    printf("哈哈哈, cublasInit这个API被我截获啦........\n");

    return func_entry();
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasShutdown() {
    HOOK_TRACE_PERF("cublasShutdown");
    using func_ptr = cublasStatus (*)();
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasShutdown"));
    HOOK_CHECK(func_entry);
    return func_entry();
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasGetError() {
    HOOK_TRACE_PERF("cublasGetError");
    using func_ptr = cublasStatus (*)();
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasGetError"));
    HOOK_CHECK(func_entry);
    return func_entry();
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasGetVersion(int * version) {
    HOOK_TRACE_PERF("cublasGetVersion");
    using func_ptr = cublasStatus (*)(int *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasGetVersion"));
    HOOK_CHECK(func_entry);
    return func_entry(version);
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasAlloc(int n, int elemSize, void * * devicePtr) {
    HOOK_TRACE_PERF("cublasAlloc");
    using func_ptr = cublasStatus (*)(int, int, void * *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasAlloc"));
    HOOK_CHECK(func_entry);
    return func_entry(n, elemSize, devicePtr);
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasFree(void * devicePtr) {
    HOOK_TRACE_PERF("cublasFree");
    using func_ptr = cublasStatus (*)(void *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasFree"));
    HOOK_CHECK(func_entry);
    return func_entry(devicePtr);
}

HOOK_C_API HOOK_DECL_EXPORT cublasStatus cublasSetKernelStream(cudaStream_t stream) {
    HOOK_TRACE_PERF("cublasSetKernelStream");
    using func_ptr = cublasStatus (*)(cudaStream_t);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSetKernelStream"));
    HOOK_CHECK(func_entry);
    return func_entry(stream);
}

HOOK_C_API HOOK_DECL_EXPORT float cublasSnrm2(int n, const float * x, int incx) {
    HOOK_TRACE_PERF("cublasSnrm2");
    using func_ptr = float (*)(int, const float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSnrm2"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT double cublasDnrm2(int n, const double * x, int incx) {
    HOOK_TRACE_PERF("cublasDnrm2");
    using func_ptr = double (*)(int, const double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDnrm2"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT float cublasScnrm2(int n, const cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasScnrm2");
    using func_ptr = float (*)(int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasScnrm2"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT double cublasDznrm2(int n, const cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasDznrm2");
    using func_ptr = double (*)(int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDznrm2"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT float cublasSdot(int n, const float * x, int incx, const float * y, int incy) {
    HOOK_TRACE_PERF("cublasSdot");
    using func_ptr = float (*)(int, const float *, int, const float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSdot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT double cublasDdot(int n, const double * x, int incx, const double * y, int incy) {
    HOOK_TRACE_PERF("cublasDdot");
    using func_ptr = double (*)(int, const double *, int, const double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDdot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT cuComplex cublasCdotu(int n, const cuComplex * x, int incx, const cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCdotu");
    using func_ptr = cuComplex (*)(int, const cuComplex *, int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCdotu"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT cuComplex cublasCdotc(int n, const cuComplex * x, int incx, const cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCdotc");
    using func_ptr = cuComplex (*)(int, const cuComplex *, int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCdotc"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT cuDoubleComplex cublasZdotu(int n, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZdotu");
    using func_ptr = cuDoubleComplex (*)(int, const cuDoubleComplex *, int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZdotu"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT cuDoubleComplex cublasZdotc(int n, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZdotc");
    using func_ptr = cuDoubleComplex (*)(int, const cuDoubleComplex *, int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZdotc"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSscal(int n, float alpha, float * x, int incx) {
    HOOK_TRACE_PERF("cublasSscal");
    using func_ptr = void (*)(int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDscal(int n, double alpha, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDscal");
    using func_ptr = void (*)(int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCscal(int n, cuComplex alpha, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCscal");
    using func_ptr = void (*)(int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZscal(int n, cuDoubleComplex alpha, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZscal");
    using func_ptr = void (*)(int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCsscal(int n, float alpha, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCsscal");
    using func_ptr = void (*)(int, float, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCsscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZdscal(int n, double alpha, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZdscal");
    using func_ptr = void (*)(int, double, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZdscal"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSaxpy(int n, float alpha, const float * x, int incx, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSaxpy");
    using func_ptr = void (*)(int, float, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSaxpy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDaxpy(int n, double alpha, const double * x, int incx, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDaxpy");
    using func_ptr = void (*)(int, double, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDaxpy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCaxpy(int n, cuComplex alpha, const cuComplex * x, int incx, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCaxpy");
    using func_ptr = void (*)(int, cuComplex, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCaxpy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZaxpy(int n, cuDoubleComplex alpha, const cuDoubleComplex * x, int incx, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZaxpy");
    using func_ptr = void (*)(int, cuDoubleComplex, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZaxpy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, alpha, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasScopy(int n, const float * x, int incx, float * y, int incy) {
    HOOK_TRACE_PERF("cublasScopy");
    using func_ptr = void (*)(int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasScopy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDcopy(int n, const double * x, int incx, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDcopy");
    using func_ptr = void (*)(int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDcopy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCcopy(int n, const cuComplex * x, int incx, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCcopy");
    using func_ptr = void (*)(int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCcopy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZcopy(int n, const cuDoubleComplex * x, int incx, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZcopy");
    using func_ptr = void (*)(int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZcopy"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSswap(int n, float * x, int incx, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSswap");
    using func_ptr = void (*)(int, float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSswap"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDswap(int n, double * x, int incx, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDswap");
    using func_ptr = void (*)(int, double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDswap"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCswap(int n, cuComplex * x, int incx, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCswap");
    using func_ptr = void (*)(int, cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCswap"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZswap(int n, cuDoubleComplex * x, int incx, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZswap");
    using func_ptr = void (*)(int, cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZswap"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIsamax(int n, const float * x, int incx) {
    HOOK_TRACE_PERF("cublasIsamax");
    using func_ptr = int (*)(int, const float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIsamax"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIdamax(int n, const double * x, int incx) {
    HOOK_TRACE_PERF("cublasIdamax");
    using func_ptr = int (*)(int, const double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIdamax"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIcamax(int n, const cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasIcamax");
    using func_ptr = int (*)(int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIcamax"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIzamax(int n, const cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasIzamax");
    using func_ptr = int (*)(int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIzamax"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIsamin(int n, const float * x, int incx) {
    HOOK_TRACE_PERF("cublasIsamin");
    using func_ptr = int (*)(int, const float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIsamin"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIdamin(int n, const double * x, int incx) {
    HOOK_TRACE_PERF("cublasIdamin");
    using func_ptr = int (*)(int, const double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIdamin"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIcamin(int n, const cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasIcamin");
    using func_ptr = int (*)(int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIcamin"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT int cublasIzamin(int n, const cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasIzamin");
    using func_ptr = int (*)(int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasIzamin"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT float cublasSasum(int n, const float * x, int incx) {
    HOOK_TRACE_PERF("cublasSasum");
    using func_ptr = float (*)(int, const float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSasum"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT double cublasDasum(int n, const double * x, int incx) {
    HOOK_TRACE_PERF("cublasDasum");
    using func_ptr = double (*)(int, const double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDasum"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT float cublasScasum(int n, const cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasScasum");
    using func_ptr = float (*)(int, const cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasScasum"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT double cublasDzasum(int n, const cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasDzasum");
    using func_ptr = double (*)(int, const cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDzasum"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSrot(int n, float * x, int incx, float * y, int incy, float sc, float ss) {
    HOOK_TRACE_PERF("cublasSrot");
    using func_ptr = void (*)(int, float *, int, float *, int, float, float);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, sc, ss);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDrot(int n, double * x, int incx, double * y, int incy, double sc, double ss) {
    HOOK_TRACE_PERF("cublasDrot");
    using func_ptr = void (*)(int, double *, int, double *, int, double, double);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, sc, ss);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCrot(int n, cuComplex * x, int incx, cuComplex * y, int incy, float c, cuComplex s) {
    HOOK_TRACE_PERF("cublasCrot");
    using func_ptr = void (*)(int, cuComplex *, int, cuComplex *, int, float, cuComplex);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, c, s);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZrot(int n, cuDoubleComplex * x, int incx, cuDoubleComplex * y, int incy, double sc, cuDoubleComplex cs) {
    HOOK_TRACE_PERF("cublasZrot");
    using func_ptr = void (*)(int, cuDoubleComplex *, int, cuDoubleComplex *, int, double, cuDoubleComplex);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, sc, cs);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCsrot(int n, cuComplex * x, int incx, cuComplex * y, int incy, float c, float s) {
    HOOK_TRACE_PERF("cublasCsrot");
    using func_ptr = void (*)(int, cuComplex *, int, cuComplex *, int, float, float);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCsrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, c, s);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZdrot(int n, cuDoubleComplex * x, int incx, cuDoubleComplex * y, int incy, double c, double s) {
    HOOK_TRACE_PERF("cublasZdrot");
    using func_ptr = void (*)(int, cuDoubleComplex *, int, cuDoubleComplex *, int, double, double);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZdrot"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, c, s);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSrotg(float * sa, float * sb, float * sc, float * ss) {
    HOOK_TRACE_PERF("cublasSrotg");
    using func_ptr = void (*)(float *, float *, float *, float *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSrotg"));
    HOOK_CHECK(func_entry);
    return func_entry(sa, sb, sc, ss);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDrotg(double * sa, double * sb, double * sc, double * ss) {
    HOOK_TRACE_PERF("cublasDrotg");
    using func_ptr = void (*)(double *, double *, double *, double *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDrotg"));
    HOOK_CHECK(func_entry);
    return func_entry(sa, sb, sc, ss);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCrotg(cuComplex * ca, cuComplex cb, float * sc, cuComplex * cs) {
    HOOK_TRACE_PERF("cublasCrotg");
    using func_ptr = void (*)(cuComplex *, cuComplex, float *, cuComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCrotg"));
    HOOK_CHECK(func_entry);
    return func_entry(ca, cb, sc, cs);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZrotg(cuDoubleComplex * ca, cuDoubleComplex cb, double * sc, cuDoubleComplex * cs) {
    HOOK_TRACE_PERF("cublasZrotg");
    using func_ptr = void (*)(cuDoubleComplex *, cuDoubleComplex, double *, cuDoubleComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZrotg"));
    HOOK_CHECK(func_entry);
    return func_entry(ca, cb, sc, cs);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSrotm(int n, float * x, int incx, float * y, int incy, const float * sparam) {
    HOOK_TRACE_PERF("cublasSrotm");
    using func_ptr = void (*)(int, float *, int, float *, int, const float *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSrotm"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, sparam);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDrotm(int n, double * x, int incx, double * y, int incy, const double * sparam) {
    HOOK_TRACE_PERF("cublasDrotm");
    using func_ptr = void (*)(int, double *, int, double *, int, const double *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDrotm"));
    HOOK_CHECK(func_entry);
    return func_entry(n, x, incx, y, incy, sparam);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSrotmg(float * sd1, float * sd2, float * sx1, const float * sy1, float * sparam) {
    HOOK_TRACE_PERF("cublasSrotmg");
    using func_ptr = void (*)(float *, float *, float *, const float *, float *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSrotmg"));
    HOOK_CHECK(func_entry);
    return func_entry(sd1, sd2, sx1, sy1, sparam);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDrotmg(double * sd1, double * sd2, double * sx1, const double * sy1, double * sparam) {
    HOOK_TRACE_PERF("cublasDrotmg");
    using func_ptr = void (*)(double *, double *, double *, const double *, double *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDrotmg"));
    HOOK_CHECK(func_entry);
    return func_entry(sd1, sd2, sx1, sy1, sparam);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSgemv(char trans, int m, int n, float alpha, const float * A, int lda, const float * x, int incx, float beta, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSgemv");
    using func_ptr = void (*)(char, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSgemv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDgemv(char trans, int m, int n, double alpha, const double * A, int lda, const double * x, int incx, double beta, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDgemv");
    using func_ptr = void (*)(char, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDgemv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCgemv(char trans, int m, int n, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * x, int incx, cuComplex beta, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCgemv");
    using func_ptr = void (*)(char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCgemv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZgemv(char trans, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * x, int incx, cuDoubleComplex beta, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZgemv");
    using func_ptr = void (*)(char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZgemv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSgbmv(char trans, int m, int n, int kl, int ku, float alpha, const float * A, int lda, const float * x, int incx, float beta, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSgbmv");
    using func_ptr = void (*)(char, int, int, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSgbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDgbmv(char trans, int m, int n, int kl, int ku, double alpha, const double * A, int lda, const double * x, int incx, double beta, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDgbmv");
    using func_ptr = void (*)(char, int, int, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDgbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCgbmv(char trans, int m, int n, int kl, int ku, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * x, int incx, cuComplex beta, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasCgbmv");
    using func_ptr = void (*)(char, int, int, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCgbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZgbmv(char trans, int m, int n, int kl, int ku, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * x, int incx, cuDoubleComplex beta, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZgbmv");
    using func_ptr = void (*)(char, int, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZgbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStrmv(char uplo, char trans, char diag, int n, const float * A, int lda, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStrmv");
    using func_ptr = void (*)(char, char, char, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStrmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtrmv(char uplo, char trans, char diag, int n, const double * A, int lda, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtrmv");
    using func_ptr = void (*)(char, char, char, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtrmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtrmv(char uplo, char trans, char diag, int n, const cuComplex * A, int lda, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtrmv");
    using func_ptr = void (*)(char, char, char, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtrmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtrmv(char uplo, char trans, char diag, int n, const cuDoubleComplex * A, int lda, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtrmv");
    using func_ptr = void (*)(char, char, char, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtrmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStbmv(char uplo, char trans, char diag, int n, int k, const float * A, int lda, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStbmv");
    using func_ptr = void (*)(char, char, char, int, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtbmv(char uplo, char trans, char diag, int n, int k, const double * A, int lda, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtbmv");
    using func_ptr = void (*)(char, char, char, int, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtbmv(char uplo, char trans, char diag, int n, int k, const cuComplex * A, int lda, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtbmv");
    using func_ptr = void (*)(char, char, char, int, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtbmv(char uplo, char trans, char diag, int n, int k, const cuDoubleComplex * A, int lda, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtbmv");
    using func_ptr = void (*)(char, char, char, int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStpmv(char uplo, char trans, char diag, int n, const float * AP, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStpmv");
    using func_ptr = void (*)(char, char, char, int, const float *, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtpmv(char uplo, char trans, char diag, int n, const double * AP, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtpmv");
    using func_ptr = void (*)(char, char, char, int, const double *, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtpmv(char uplo, char trans, char diag, int n, const cuComplex * AP, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtpmv");
    using func_ptr = void (*)(char, char, char, int, const cuComplex *, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtpmv(char uplo, char trans, char diag, int n, const cuDoubleComplex * AP, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtpmv");
    using func_ptr = void (*)(char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStrsv(char uplo, char trans, char diag, int n, const float * A, int lda, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStrsv");
    using func_ptr = void (*)(char, char, char, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStrsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtrsv(char uplo, char trans, char diag, int n, const double * A, int lda, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtrsv");
    using func_ptr = void (*)(char, char, char, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtrsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtrsv(char uplo, char trans, char diag, int n, const cuComplex * A, int lda, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtrsv");
    using func_ptr = void (*)(char, char, char, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtrsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtrsv(char uplo, char trans, char diag, int n, const cuDoubleComplex * A, int lda, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtrsv");
    using func_ptr = void (*)(char, char, char, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtrsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStpsv(char uplo, char trans, char diag, int n, const float * AP, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStpsv");
    using func_ptr = void (*)(char, char, char, int, const float *, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStpsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtpsv(char uplo, char trans, char diag, int n, const double * AP, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtpsv");
    using func_ptr = void (*)(char, char, char, int, const double *, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtpsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtpsv(char uplo, char trans, char diag, int n, const cuComplex * AP, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtpsv");
    using func_ptr = void (*)(char, char, char, int, const cuComplex *, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtpsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtpsv(char uplo, char trans, char diag, int n, const cuDoubleComplex * AP, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtpsv");
    using func_ptr = void (*)(char, char, char, int, const cuDoubleComplex *, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtpsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, AP, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStbsv(char uplo, char trans, char diag, int n, int k, const float * A, int lda, float * x, int incx) {
    HOOK_TRACE_PERF("cublasStbsv");
    using func_ptr = void (*)(char, char, char, int, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStbsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtbsv(char uplo, char trans, char diag, int n, int k, const double * A, int lda, double * x, int incx) {
    HOOK_TRACE_PERF("cublasDtbsv");
    using func_ptr = void (*)(char, char, char, int, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtbsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtbsv(char uplo, char trans, char diag, int n, int k, const cuComplex * A, int lda, cuComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasCtbsv");
    using func_ptr = void (*)(char, char, char, int, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtbsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtbsv(char uplo, char trans, char diag, int n, int k, const cuDoubleComplex * A, int lda, cuDoubleComplex * x, int incx) {
    HOOK_TRACE_PERF("cublasZtbsv");
    using func_ptr = void (*)(char, char, char, int, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtbsv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, diag, n, k, A, lda, x, incx);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsymv(char uplo, int n, float alpha, const float * A, int lda, const float * x, int incx, float beta, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSsymv");
    using func_ptr = void (*)(char, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsymv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsymv(char uplo, int n, double alpha, const double * A, int lda, const double * x, int incx, double beta, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDsymv");
    using func_ptr = void (*)(char, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsymv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChemv(char uplo, int n, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * x, int incx, cuComplex beta, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasChemv");
    using func_ptr = void (*)(char, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChemv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhemv(char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * x, int incx, cuDoubleComplex beta, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZhemv");
    using func_ptr = void (*)(char, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhemv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsbmv(char uplo, int n, int k, float alpha, const float * A, int lda, const float * x, int incx, float beta, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSsbmv");
    using func_ptr = void (*)(char, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsbmv(char uplo, int n, int k, double alpha, const double * A, int lda, const double * x, int incx, double beta, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDsbmv");
    using func_ptr = void (*)(char, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChbmv(char uplo, int n, int k, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * x, int incx, cuComplex beta, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasChbmv");
    using func_ptr = void (*)(char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhbmv(char uplo, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * x, int incx, cuDoubleComplex beta, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZhbmv");
    using func_ptr = void (*)(char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhbmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, k, alpha, A, lda, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSspmv(char uplo, int n, float alpha, const float * AP, const float * x, int incx, float beta, float * y, int incy) {
    HOOK_TRACE_PERF("cublasSspmv");
    using func_ptr = void (*)(char, int, float, const float *, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSspmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, AP, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDspmv(char uplo, int n, double alpha, const double * AP, const double * x, int incx, double beta, double * y, int incy) {
    HOOK_TRACE_PERF("cublasDspmv");
    using func_ptr = void (*)(char, int, double, const double *, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDspmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, AP, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChpmv(char uplo, int n, cuComplex alpha, const cuComplex * AP, const cuComplex * x, int incx, cuComplex beta, cuComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasChpmv");
    using func_ptr = void (*)(char, int, cuComplex, const cuComplex *, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, AP, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhpmv(char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex * AP, const cuDoubleComplex * x, int incx, cuDoubleComplex beta, cuDoubleComplex * y, int incy) {
    HOOK_TRACE_PERF("cublasZhpmv");
    using func_ptr = void (*)(char, int, cuDoubleComplex, const cuDoubleComplex *, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhpmv"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, AP, x, incx, beta, y, incy);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSger(int m, int n, float alpha, const float * x, int incx, const float * y, int incy, float * A, int lda) {
    HOOK_TRACE_PERF("cublasSger");
    using func_ptr = void (*)(int, int, float, const float *, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSger"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDger(int m, int n, double alpha, const double * x, int incx, const double * y, int incy, double * A, int lda) {
    HOOK_TRACE_PERF("cublasDger");
    using func_ptr = void (*)(int, int, double, const double *, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDger"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCgeru(int m, int n, cuComplex alpha, const cuComplex * x, int incx, const cuComplex * y, int incy, cuComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasCgeru");
    using func_ptr = void (*)(int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCgeru"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCgerc(int m, int n, cuComplex alpha, const cuComplex * x, int incx, const cuComplex * y, int incy, cuComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasCgerc");
    using func_ptr = void (*)(int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCgerc"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZgeru(int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy, cuDoubleComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasZgeru");
    using func_ptr = void (*)(int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZgeru"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZgerc(int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy, cuDoubleComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasZgerc");
    using func_ptr = void (*)(int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZgerc"));
    HOOK_CHECK(func_entry);
    return func_entry(m, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsyr(char uplo, int n, float alpha, const float * x, int incx, float * A, int lda) {
    HOOK_TRACE_PERF("cublasSsyr");
    using func_ptr = void (*)(char, int, float, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsyr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsyr(char uplo, int n, double alpha, const double * x, int incx, double * A, int lda) {
    HOOK_TRACE_PERF("cublasDsyr");
    using func_ptr = void (*)(char, int, double, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsyr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCher(char uplo, int n, float alpha, const cuComplex * x, int incx, cuComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasCher");
    using func_ptr = void (*)(char, int, float, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCher"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZher(char uplo, int n, double alpha, const cuDoubleComplex * x, int incx, cuDoubleComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasZher");
    using func_ptr = void (*)(char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZher"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSspr(char uplo, int n, float alpha, const float * x, int incx, float * AP) {
    HOOK_TRACE_PERF("cublasSspr");
    using func_ptr = void (*)(char, int, float, const float *, int, float *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSspr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDspr(char uplo, int n, double alpha, const double * x, int incx, double * AP) {
    HOOK_TRACE_PERF("cublasDspr");
    using func_ptr = void (*)(char, int, double, const double *, int, double *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDspr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChpr(char uplo, int n, float alpha, const cuComplex * x, int incx, cuComplex * AP) {
    HOOK_TRACE_PERF("cublasChpr");
    using func_ptr = void (*)(char, int, float, const cuComplex *, int, cuComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChpr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhpr(char uplo, int n, double alpha, const cuDoubleComplex * x, int incx, cuDoubleComplex * AP) {
    HOOK_TRACE_PERF("cublasZhpr");
    using func_ptr = void (*)(char, int, double, const cuDoubleComplex *, int, cuDoubleComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhpr"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsyr2(char uplo, int n, float alpha, const float * x, int incx, const float * y, int incy, float * A, int lda) {
    HOOK_TRACE_PERF("cublasSsyr2");
    using func_ptr = void (*)(char, int, float, const float *, int, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsyr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsyr2(char uplo, int n, double alpha, const double * x, int incx, const double * y, int incy, double * A, int lda) {
    HOOK_TRACE_PERF("cublasDsyr2");
    using func_ptr = void (*)(char, int, double, const double *, int, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsyr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCher2(char uplo, int n, cuComplex alpha, const cuComplex * x, int incx, const cuComplex * y, int incy, cuComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasCher2");
    using func_ptr = void (*)(char, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCher2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZher2(char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy, cuDoubleComplex * A, int lda) {
    HOOK_TRACE_PERF("cublasZher2");
    using func_ptr = void (*)(char, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZher2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, A, lda);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSspr2(char uplo, int n, float alpha, const float * x, int incx, const float * y, int incy, float * AP) {
    HOOK_TRACE_PERF("cublasSspr2");
    using func_ptr = void (*)(char, int, float, const float *, int, const float *, int, float *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSspr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDspr2(char uplo, int n, double alpha, const double * x, int incx, const double * y, int incy, double * AP) {
    HOOK_TRACE_PERF("cublasDspr2");
    using func_ptr = void (*)(char, int, double, const double *, int, const double *, int, double *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDspr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChpr2(char uplo, int n, cuComplex alpha, const cuComplex * x, int incx, const cuComplex * y, int incy, cuComplex * AP) {
    HOOK_TRACE_PERF("cublasChpr2");
    using func_ptr = void (*)(char, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChpr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhpr2(char uplo, int n, cuDoubleComplex alpha, const cuDoubleComplex * x, int incx, const cuDoubleComplex * y, int incy, cuDoubleComplex * AP) {
    HOOK_TRACE_PERF("cublasZhpr2");
    using func_ptr = void (*)(char, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex *);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhpr2"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, n, alpha, x, incx, y, incy, AP);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSgemm(char transa, char transb, int m, int n, int k, float alpha, const float * A, int lda, const float * B, int ldb, float beta, float * C, int ldc) {
    HOOK_TRACE_PERF("cublasSgemm");
    using func_ptr = void (*)(char, char, int, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSgemm"));
    HOOK_CHECK(func_entry);

    printf("哈哈哈, cublasSgemm这个API被我截获啦........\n");
    return func_entry(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDgemm(char transa, char transb, int m, int n, int k, double alpha, const double * A, int lda, const double * B, int ldb, double beta, double * C, int ldc) {
    HOOK_TRACE_PERF("cublasDgemm");
    using func_ptr = void (*)(char, char, int, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDgemm"));
    HOOK_CHECK(func_entry);
    return func_entry(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCgemm(char transa, char transb, int m, int n, int k, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * B, int ldb, cuComplex beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCgemm");
    using func_ptr = void (*)(char, char, int, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCgemm"));
    HOOK_CHECK(func_entry);
    return func_entry(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZgemm(char transa, char transb, int m, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * B, int ldb, cuDoubleComplex beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZgemm");
    using func_ptr = void (*)(char, char, int, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZgemm"));
    HOOK_CHECK(func_entry);
    return func_entry(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsyrk(char uplo, char trans, int n, int k, float alpha, const float * A, int lda, float beta, float * C, int ldc) {
    HOOK_TRACE_PERF("cublasSsyrk");
    using func_ptr = void (*)(char, char, int, int, float, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsyrk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsyrk(char uplo, char trans, int n, int k, double alpha, const double * A, int lda, double beta, double * C, int ldc) {
    HOOK_TRACE_PERF("cublasDsyrk");
    using func_ptr = void (*)(char, char, int, int, double, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsyrk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCsyrk(char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex * A, int lda, cuComplex beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCsyrk");
    using func_ptr = void (*)(char, char, int, int, cuComplex, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCsyrk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZsyrk(char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, cuDoubleComplex beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZsyrk");
    using func_ptr = void (*)(char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZsyrk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCherk(char uplo, char trans, int n, int k, float alpha, const cuComplex * A, int lda, float beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCherk");
    using func_ptr = void (*)(char, char, int, int, float, const cuComplex *, int, float, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCherk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZherk(char uplo, char trans, int n, int k, double alpha, const cuDoubleComplex * A, int lda, double beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZherk");
    using func_ptr = void (*)(char, char, int, int, double, const cuDoubleComplex *, int, double, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZherk"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsyr2k(char uplo, char trans, int n, int k, float alpha, const float * A, int lda, const float * B, int ldb, float beta, float * C, int ldc) {
    HOOK_TRACE_PERF("cublasSsyr2k");
    using func_ptr = void (*)(char, char, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsyr2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsyr2k(char uplo, char trans, int n, int k, double alpha, const double * A, int lda, const double * B, int ldb, double beta, double * C, int ldc) {
    HOOK_TRACE_PERF("cublasDsyr2k");
    using func_ptr = void (*)(char, char, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsyr2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCsyr2k(char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * B, int ldb, cuComplex beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCsyr2k");
    using func_ptr = void (*)(char, char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCsyr2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZsyr2k(char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * B, int ldb, cuDoubleComplex beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZsyr2k");
    using func_ptr = void (*)(char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZsyr2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCher2k(char uplo, char trans, int n, int k, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * B, int ldb, float beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCher2k");
    using func_ptr = void (*)(char, char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, float, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCher2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZher2k(char uplo, char trans, int n, int k, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * B, int ldb, double beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZher2k");
    using func_ptr = void (*)(char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, double, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZher2k"));
    HOOK_CHECK(func_entry);
    return func_entry(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasSsymm(char side, char uplo, int m, int n, float alpha, const float * A, int lda, const float * B, int ldb, float beta, float * C, int ldc) {
    HOOK_TRACE_PERF("cublasSsymm");
    using func_ptr = void (*)(char, char, int, int, float, const float *, int, const float *, int, float, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasSsymm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDsymm(char side, char uplo, int m, int n, double alpha, const double * A, int lda, const double * B, int ldb, double beta, double * C, int ldc) {
    HOOK_TRACE_PERF("cublasDsymm");
    using func_ptr = void (*)(char, char, int, int, double, const double *, int, const double *, int, double, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDsymm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCsymm(char side, char uplo, int m, int n, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * B, int ldb, cuComplex beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasCsymm");
    using func_ptr = void (*)(char, char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCsymm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZsymm(char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * B, int ldb, cuDoubleComplex beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZsymm");
    using func_ptr = void (*)(char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZsymm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasChemm(char side, char uplo, int m, int n, cuComplex alpha, const cuComplex * A, int lda, const cuComplex * B, int ldb, cuComplex beta, cuComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasChemm");
    using func_ptr = void (*)(char, char, int, int, cuComplex, const cuComplex *, int, const cuComplex *, int, cuComplex, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasChemm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZhemm(char side, char uplo, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, const cuDoubleComplex * B, int ldb, cuDoubleComplex beta, cuDoubleComplex * C, int ldc) {
    HOOK_TRACE_PERF("cublasZhemm");
    using func_ptr = void (*)(char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, const cuDoubleComplex *, int, cuDoubleComplex, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZhemm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStrsm(char side, char uplo, char transa, char diag, int m, int n, float alpha, const float * A, int lda, float * B, int ldb) {
    HOOK_TRACE_PERF("cublasStrsm");
    using func_ptr = void (*)(char, char, char, char, int, int, float, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStrsm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, const double * A, int lda, double * B, int ldb) {
    HOOK_TRACE_PERF("cublasDtrsm");
    using func_ptr = void (*)(char, char, char, char, int, int, double, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtrsm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtrsm(char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, const cuComplex * A, int lda, cuComplex * B, int ldb) {
    HOOK_TRACE_PERF("cublasCtrsm");
    using func_ptr = void (*)(char, char, char, char, int, int, cuComplex, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtrsm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtrsm(char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, cuDoubleComplex * B, int ldb) {
    HOOK_TRACE_PERF("cublasZtrsm");
    using func_ptr = void (*)(char, char, char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtrsm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasStrmm(char side, char uplo, char transa, char diag, int m, int n, float alpha, const float * A, int lda, float * B, int ldb) {
    HOOK_TRACE_PERF("cublasStrmm");
    using func_ptr = void (*)(char, char, char, char, int, int, float, const float *, int, float *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasStrmm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasDtrmm(char side, char uplo, char transa, char diag, int m, int n, double alpha, const double * A, int lda, double * B, int ldb) {
    HOOK_TRACE_PERF("cublasDtrmm");
    using func_ptr = void (*)(char, char, char, char, int, int, double, const double *, int, double *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasDtrmm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasCtrmm(char side, char uplo, char transa, char diag, int m, int n, cuComplex alpha, const cuComplex * A, int lda, cuComplex * B, int ldb) {
    HOOK_TRACE_PERF("cublasCtrmm");
    using func_ptr = void (*)(char, char, char, char, int, int, cuComplex, const cuComplex *, int, cuComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasCtrmm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}

HOOK_C_API HOOK_DECL_EXPORT void cublasZtrmm(char side, char uplo, char transa, char diag, int m, int n, cuDoubleComplex alpha, const cuDoubleComplex * A, int lda, cuDoubleComplex * B, int ldb) {
    HOOK_TRACE_PERF("cublasZtrmm");
    using func_ptr = void (*)(char, char, char, char, int, int, cuDoubleComplex, const cuDoubleComplex *, int, cuDoubleComplex *, int);
    static auto func_entry = reinterpret_cast<func_ptr>(HOOK_CUBLAS_SYMBOL("cublasZtrmm"));
    HOOK_CHECK(func_entry);
    return func_entry(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
}
